package cn.gzsxt.service.impl;

import static org.hamcrest.CoreMatchers.nullValue;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.management.RuntimeErrorException;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.gzsxt.mapper.AdminMapper;
import cn.gzsxt.mapper.DictionaryMapper;
import cn.gzsxt.mapper.ModularMapper;
import cn.gzsxt.mapper.PermissionMapper;
import cn.gzsxt.mapper.RoleMapper;
import cn.gzsxt.service.AdminService;
import cn.gzsxt.utils.Page;

@Service
public class AdminServiceImpl implements AdminService {
	
	private static final Logger LOGGER=LogManager.getLogger(AdminServiceImpl.class);

	private static final String Integer = null;
	
	@Autowired
	private AdminMapper adminMapper;
	@Autowired
	private DictionaryMapper dictionaryMapper;
	@Autowired
	private RoleMapper roleMapper;
	@Autowired
	private PermissionMapper permissionMapper;
	@Autowired
	private ModularMapper modularMapper;

	public Map<String, Object> addAdmin(Map<String, Object> admin) {
		int count = adminMapper.insert(admin);
		if (count>0) {
			return admin;
		}
		return null;
	}

	@Override
	public int deleteAdminByIds(Object... adminIds) {
		return adminMapper.deleteByIds(adminIds);
	}

	@Override
	public Map<String, Object> editAdmin(Map<String, Object> admin) {
		int count = adminMapper.updateForNotnull(admin);
		if (count>0) {
			return admin;
		}
		return null;
	}
	
	@Override
	public Map<String, Object> editAdminPassword(Map<String, Object> admin) {
		//通过管理员编号更新指定的密码字段
		
		//第一步：我们只需要更新密码字段，所以我们需要构建一个实体，只包含ADMIN_ID、ADMIN_PWD
		Map<String, Object> params=new HashMap<>();
		params.put("ADMIN_ID", admin.get("ADMIN_ID"));
		params.put("ADMIN_PWD", admin.get("ADMIN_PWD"));
		//第二步：更新密码字段
		int count = adminMapper.updateForNotnull(params);
		if (count>0) {
			return admin;
		}
		
		return null;
	}

	@Override
	public Page findAdminByConditionToPage(Map<String, Object> condition, int index, int size) {
		//构建一个分页对象
		//1.获得总记录数据
		long count = adminMapper.count(condition);
		//2.获得分页数据
		int start=index*size;
		List<Map<String, Object>> moduarls = adminMapper.findByConditionAndPage(condition, start, size);
		//将用户状态拼接到列表里面
		for (Map<String, Object> modular : moduarls) {
			//获得ADMIN表的管理员状态
			Object status = modular.get("ADMIN_STATUS");
			//通过状态值获得字典记录
			Map<String, Object> dic = dictionaryMapper.findByTypeCodeAndValue("1001", status);
			//将字典记录的对应值的名称覆盖到管理员列表
			modular.put("ADMIN_STATUS", dic.get("DICTIONARY_NAME"));
			
			//将角色的信息拼接到管理员列表
			Object roleId = modular.get("ROLE_ID");
			//通过角色编号查询角色记录
			Map<String, Object> role = roleMapper.findById(roleId);
			//将角色信息返回管理员列表
			modular.put("role", role);
			
			
			LOGGER.debug(modular);
			
		}
		
		
		
		//3.构建分页对象
		Page page=new Page(index, size, count, moduarls);
		//4.返回分页对象
		return page;
	}



	@Override
	public Map<String, Object> findAdminById(Object adminId) {
		
		return adminMapper.findById(adminId);
	}

	@Override
	public List<Map<String, Object>> findAllAdmin() {
		return adminMapper.findAll();
	}

	@Override
	public Map<String, Object> loginAdmin(Map<String, Object> admin) {
		//登录的业务逻辑是什么
		//第一步：获得页面传递的数据 admin
		//第二步：通过账号名获得数据库对应数据 - 通过账号名查询记录
		Map<String, Object> resultAdmin = adminMapper.findByAccount(admin.get("ADMIN_ACCOUNT"));
		
		//判断登录用户是否禁用
		Integer adminStatus=(Integer)resultAdmin.get("ADMIN_STATUS");
		if (adminStatus!=0) {
			
			throw new RuntimeException("用户已经禁用");
		}
		
		//第三步：如果有对应的记录，判断数据库记录的密码与页面传递的密码是否相同
		if (resultAdmin!=null) {
			if (admin.get("ADMIN_PWD").equals(resultAdmin.get("ADMIN_PWD"))) {
				//1.获得登录管理员的角色信息
				Object roleId = resultAdmin.get("ROLE_ID");
				Map<String, Object> role = roleMapper.findById(roleId);
				resultAdmin.put("role", role);
				//2.将角色的权限信息，放在角色里面
				String permissionIds = (String)role.get("ROLE_PERMISSIONS");
				String[] permissionIdArr = permissionIds.split(",");
				List<Map<String, Object>> permisssions = permissionMapper.findByIds((Object[])permissionIdArr);
				role.put("permisssions", permisssions);
				
				//3.将权限的模块放在管理员信息里面。需要去重复
				//加入数据到集合里面，而且不要加入重复数据的思路
				//第一步：声明一个集合
				List<Map<String, Object>> modulars=new ArrayList<>();
				//第二步：通过循环将所有的数据放在声明好的modulars集合里面
				for (Map<String, Object> permisssion : permisssions) {
					//第三步：声明一个标记变量，用于标记数据是否是重复的
					boolean flag=false;
					//第四步：模块编号，是一个判断是否重复的条件
					Object modularId = permisssion.get("MODULAR_ID");
					//第五步：判断集合里面是否有重复的模块编号了，如果已经有就跳过
					for (Map<String, Object> m : modulars) {
						//通过循环来逐条判断已经增加到modulars集合里面的模块的编号，是否与第四步获得的模块编号是否相同
						if(m.get("MODULAR_ID")==modularId){
							//如果只要有一条相同，就表示数据重复了。将标记变量修改为true。
							//注意：我们将true == 数据重复
							flag=true;
							//既然发生重复的数据了，就不需要在判断其他了，直接终止该循环就可以了
							break;
						}
					}
					//第六步：前面的逻辑，实现了 true == 数据重复了
					if (flag==true) {
						//如果数据时重复的，就跳过当次循环
						continue;
					}else{
						//如果不是重复的，才查询模块信息，加入到集合里面
						Map<String, Object> modular = modularMapper.findById(modularId);
						modulars.add(modular);
						LOGGER.debug("模块信息："+modular);
					}
			
				
					
				
					
					
				}
				//将模块数据放在管理员对象里面
				resultAdmin.put("modulars", modulars);
				
				LOGGER.debug("登录管理员信息："+resultAdmin);
				
				return resultAdmin;
			}
			
			
		}
		
		//第四步：匹配就返回查询的记录，否则返回null
		return null;
	}


}
